home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 05 - 1989 / 05.08 Aug 89 / POOPDraw Code ƒ / CLSS DrawObject.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-12  |  11.2 KB  |  418 lines  |  [TEXT/KAHL]
  1. /********************************************************************/
  2. /*                        SOURCE CODE FILE                            */
  3. /********************************************************************/
  4. /*
  5. *   >>>    File name:        CLSS DrawObject.c    
  6. *
  7. *      >>>    Purpose:        Methods for Draw Objects
  8. *     >>>    Project:        PoopDraw    Version 1        
  9. *     >>>    Date:            2/20/89
  10. *      >>>    By:                Adam Treister
  11. *
  12. */
  13. /********************************************************************/
  14. /*    For Your Information            1802 Hillside Rd. SB CA 93101    */
  15. /********************************************************************/
  16.  
  17. #include "PoopDrawInc"
  18.  
  19. /***** Private Functions *********************************************/
  20.  
  21.  
  22. private void Init(DrawObjectHandle ObjectH,LPtr InParmP);
  23. private void Dispose(DrawObjectHandle ObjectH);    
  24. private void Draw(DrawObjectHandle ObjectH);    
  25. private void MouseDown(DrawObjectHandle ObjectH);    
  26. private void KeyDown(DrawObjectHandle ObjectH,LPtr InParmP);    
  27.  
  28. int PtInDrawObjectHandle(Point pt,DrawObjectHandle ObjectH);
  29. private void ToggleSelect(DrawObjectHandle ObjectH);
  30. private void DragActiveObjects(ObjectHandle    TheWindowData);
  31. private void TrackPtInHandle(Point pt,DrawObjectHandle ObjectH);
  32. private void AdjustObjBounds(Rect *rP,int handleNumber);
  33.  
  34. private void DrawHandles(DrawObjectHandle ObjectH);
  35. private void Inval(DrawObjectHandle ObjectH);
  36. private void SelectRect(DrawObjectHandle ObjectH,LPtr InParmP);
  37.  
  38. private void SetFill(DrawObjectHandle ObjectH,LPtr InParmP);
  39. private void SetPenPat(DrawObjectHandle ObjectH,LPtr InParmP);
  40. private void SetPenSize(DrawObjectHandle ObjectH,LPtr InParmP);
  41.  
  42. Pack(DrawObjectHandle ObjectH,Handle h);
  43. void UnPack(DrawObjectHandle ObjectH,Ptr *pP);
  44. SetLength(DrawObjectHandle ObjectH);
  45. #define SKIP2FLDS  8L
  46.  
  47.  
  48. /***** Dispatch *****************************************************/
  49.  
  50. void DrawObjectDispatch(ObjectH,Message,ParmP)
  51. ObjectHandle ObjectH;
  52. int Message;
  53. LPtr ParmP;
  54.  
  55. {
  56.     switch(Message)
  57.     {
  58.     
  59.         case INIT:            Init(ObjectH,ParmP);                            break;
  60.         case DISPOSE:        Dispose(ObjectH);                                break;
  61.         case DRAWHANDLES:    DrawHandles(ObjectH);                            break;
  62.         case MOUSEDOWN:        MouseDown(ObjectH);                                break;
  63.         case TRACK:            TrackPtInHandle(*(Point *)ParmP, ObjectH);        break;
  64.         case INVAL:            
  65.         case ERASE:            Inval(ObjectH);                                    break;
  66.  
  67.          case SELECT:        BitSet(&(*ObjectH)->attributes,SelectedBit);
  68.                              Inval(ObjectH);                                    break;
  69.          case UNSELECT:        BitClr(&(*ObjectH)->attributes,SelectedBit);    
  70.                              Inval(ObjectH);                                    break;
  71.         case SELECTRECT:    SelectRect(ObjectH,ParmP);                        break;
  72.         
  73.         case FILL:            SetFill(ObjectH,ParmP);                            break;
  74.         case PENPAT:        SetPenPat(ObjectH,ParmP);                        break;
  75.         case PENSIZE:        SetPenSize(ObjectH,ParmP);                        break;
  76.  
  77.         case SETLEN:        SetLength(ObjectH);                                break;
  78.         case PACK:            Pack(ObjectH,ParmP);                            break;
  79.         case UNPACK:        UnPack(ObjectH,ParmP);                            break;
  80.  
  81.         default:            ObjectDispatch(ObjectH,Message,ParmP);            break;
  82.     }
  83. }    
  84.  
  85.  
  86. /********************************************************************/
  87. DrawObjectHandle MakeDrawObject(void);
  88.  
  89. DrawObjectHandle MakeDrawObject()
  90. {
  91.     DrawObjectHandle ObjectH;
  92.     
  93.     ObjectH = _GetHandleToRecord(DrawObjectRec);
  94.     (*ObjectH)->dispatch = DrawObjectDispatch;
  95.     return(ObjectH);
  96. }
  97.  
  98. /*---------------------------------------------------------------*/
  99. void Init(ObjectH,ParmP)
  100. register DrawObjectHandle ObjectH;
  101. LPtr ParmP;
  102.  
  103. {
  104.     
  105.     (*ObjectH)->bounds = *((Rect *) ParmP);
  106.     BitSet(&(*ObjectH)->attributes,VisibleBit);    
  107.     GetPort(&(*ObjectH)->port);
  108.     WDispatch((*ObjectH)->port,GETDRAWSTATE,&(*ObjectH)->drawState);
  109. }
  110.  
  111. /*-----------------------------------generic method--------------*/
  112. /*
  113. *    Function:            --    Dispose
  114. *
  115. *    Date:                --    Feb. 20, 1989
  116. *    PoopDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  117. /*---------------------------------------------------------------*/
  118.  
  119. void Dispose(ObjectH)
  120. register DrawObjectHandle ObjectH;
  121.  
  122. {
  123.     Inval(SELF);
  124.     WDispatch((*ObjectH)->port,DELOBJECT,SELF);
  125.     DisposeHandle(ObjectH);
  126.     
  127. }
  128. /*-----------------------------------generic method--------------*/
  129. /*
  130. *    Function:            --    MouseDown
  131. *
  132. *    Date:                --    Feb. 20, 1989
  133. *    PoopDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  134. /*---------------------------------------------------------------*/
  135. void MouseDown(ObjectH)
  136. register DrawObjectHandle ObjectH;
  137.  
  138. {
  139.         register ObjectHandle WindowData;
  140.         extern EventRecord Event;
  141.         int spot;
  142.         Point pt;
  143.         WindowPtr wP;
  144.         
  145.     WindowData = (ObjectHandle) GetWRefCon(wP = (*ObjectH)->port);
  146.     pt = Event.where;
  147.     GlobalToLocal(&pt);
  148.     spot = PtInDrawObjectHandle(pt,ObjectH);
  149.  
  150.     if (spot)
  151.         if (spot == 5)    
  152.         {
  153.             if (_ShiftKeyDown(Event))        ToggleSelect(ObjectH);
  154.             else    if (BitTst(&(*ObjectH)->attributes,SelectedBit))    
  155.                     {
  156.                             WDispatch(wP,MOVE,NULL);
  157.                     }
  158.                     else    
  159.                     {
  160.                         WDispatch(wP,CLRSELECT,NULL);
  161.                         WDispatch(wP,SELECT,ObjectH);
  162.                         Dispatch(ObjectH,SELECT,NULL);
  163.                     }
  164.         }
  165.         else    Dispatch(ObjectH,TRACK,&pt);
  166.  
  167. }
  168. /*---------------------------------------------------------------*/
  169. void KeyDown(ObjectH,InParms)
  170. register DrawObjectHandle ObjectH;
  171. LPtr InParms;
  172.  
  173. {
  174.     if ((*InParms & charCodeMask) == BACKSPACE)        
  175.         Dispatch(SELF,ERASE,NULL);
  176.         
  177. }
  178. /*---------------------------------------------------------------*/
  179. void ToggleSelect(ObjectH)
  180. register DrawObjectHandle ObjectH;
  181. {
  182.     int message;
  183.     Boolean isSelected;
  184.     
  185.     isSelected  =  BitTst(&(*ObjectH)->attributes,SelectedBit);
  186.     message = (isSelected) ? UNSELECT : SELECT;
  187.     WDispatch((*ObjectH)->port,message,ObjectH);
  188.     Dispatch(ObjectH,message,NULL);
  189. }
  190. /*---------------------------------------------------------------*/
  191. void Inval(ObjectH)
  192. register DrawObjectHandle ObjectH;
  193.  
  194. {
  195.     Rect r;
  196.     
  197.     r = (*ObjectH)->bounds;
  198.     InsetRect(&r,-HANDLEWIDTH,-HANDLEWIDTH);
  199.     EraseRect(&r);
  200.     InvalRect(&r);
  201. }
  202. /*---------------------------------------------------------------*/
  203. void SetFill(ObjectH,ParmP)
  204. register DrawObjectHandle ObjectH;
  205. LPtr ParmP;
  206. {
  207.     Dispatch(ObjectH,INVAL,NULL);
  208.     (*ObjectH)->drawState.fillPat = * (IPtr)ParmP;
  209. }
  210. /*---------------------------------------------------------------*/
  211. void SetPenPat(ObjectH,ParmP)
  212. register DrawObjectHandle ObjectH;
  213. LPtr ParmP;
  214. {
  215.     Dispatch(ObjectH,INVAL,NULL);
  216.     (*ObjectH)->drawState.penPat =  * (IPtr)ParmP;
  217. }
  218. /*---------------------------------------------------------------*/
  219. void SetPenSize(ObjectH,ParmP)
  220. register DrawObjectHandle ObjectH;
  221. LPtr ParmP;
  222. {
  223.     Dispatch(ObjectH,INVAL,NULL);
  224.     (*ObjectH)->drawState.penSize = * (IPtr)ParmP;
  225.  
  226. }
  227. /*---------------------------------------------------------------*/
  228.  
  229. void DrawHandles(ObjectH)
  230. register DrawObjectHandle ObjectH;
  231.  
  232. {
  233.             Rect r,objRect;
  234.             int HalfObjWidth,HalfObjHeight;
  235.             PenState penSave;
  236.             
  237.      GetPenState(&penSave);
  238.      PenPat(black);    PenMode(patXor);
  239.  
  240.      objRect = (*ObjectH)->bounds;
  241.      SetRect(&r,objRect.left-HANDLEWIDTH+2,objRect.top-HANDLEWIDTH+2,
  242.                  objRect.left+HANDLEWIDTH-2,objRect.top+HANDLEWIDTH-2);
  243.  
  244.      HalfObjWidth = Width(objRect) / 2;
  245.      HalfObjHeight = Height(objRect) / 2;
  246.     
  247.      PaintRect(&r);    OffsetRect(&r,HalfObjWidth,0);
  248.      PaintRect(&r);    OffsetRect(&r,HalfObjWidth,0);
  249.      PaintRect(&r);    OffsetRect(&r,0,HalfObjHeight);
  250.      PaintRect(&r);    OffsetRect(&r,0,HalfObjHeight);
  251.      PaintRect(&r);    OffsetRect(&r,-HalfObjWidth,0);
  252.      PaintRect(&r);    OffsetRect(&r,-HalfObjWidth,0);
  253.      PaintRect(&r);    OffsetRect(&r,0,-HalfObjHeight);
  254.      PaintRect(&r);
  255.      PenMode(patCopy);
  256.      SetPenState(&penSave);
  257. }
  258. /*---------------------------------------------------------------*/
  259. /*
  260. *    Function:            --    PtInDrawObjectHandle
  261. *
  262. *    This function returns the numbers 1 thru 9  to specify
  263. *    which handle the point was in. 0 means the point is in neither
  264. *    the object nor a handle.  5 means pt is in the center.
  265. *
  266. *    Date:                --    Feb. 20, 1989
  267. *    PoopDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  268. /*---------------------------------------------------------------*/
  269.  
  270. int PtInDrawObjectHandle(pt,ObjectH)
  271. Point pt;
  272. register DrawObjectHandle ObjectH;
  273. {
  274.     Rect Rim;
  275.     register int vCoord,hCoord;
  276.     register int vCenter,hCenter;
  277.     Boolean inRect;
  278.     
  279.     Rim = (*ObjectH)->bounds;
  280.     InsetRect(&Rim,-(HANDLEWIDTH-2),-(HANDLEWIDTH-2));
  281.     inRect = PtInRect(pt,&Rim);
  282.     if ((*ObjectH)->class == GROUP)        return(inRect ? 5 : 0);
  283.     vCenter = (Rim.top + Rim.bottom) / 2;
  284.     hCenter = (Rim.left + Rim.right) / 2;
  285.  
  286.     if         (ABS(pt.v - Rim.top) <= HANDLEWIDTH)    vCoord = 0;
  287.     else if (ABS(pt.v - vCenter) <= HANDLEWIDTH)    vCoord = 1;
  288.     else if (ABS(pt.v - Rim.bottom) <= HANDLEWIDTH)    vCoord = 2;
  289.     else    return(inRect ? 5 : 0);
  290.     
  291.     if         (ABS(pt.h - Rim.left) <= HANDLEWIDTH)    hCoord = 0;
  292.     else if (ABS(pt.h - hCenter) <= HANDLEWIDTH)    hCoord = 1;
  293.     else if (ABS(pt.h - Rim.right) <= HANDLEWIDTH)    hCoord = 2;
  294.     else    return(inRect ? 5 : 0);
  295.  
  296.     return( 3 * vCoord + hCoord + 1);
  297. }
  298.  
  299.  
  300. /*---------------------------------------------------------------*/
  301. /*
  302. *    Function:            --    TrackPtInHandle
  303. *
  304. *
  305. *    Date:                --    Feb. 20, 1989
  306. *    PoopDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  307. /*---------------------------------------------------------------*/
  308.  
  309.  
  310. void TrackPtInHandle(pt, ObjectH)
  311. Point                pt;
  312. DrawObjectHandle        ObjectH;
  313.     
  314. {
  315.     
  316.     Rect     newRect,InnerRim,OuterRim;    
  317.     int     handleNumber;
  318.     Point    endPos;
  319.     
  320.     InnerRim = OuterRim = newRect = (*ObjectH)->bounds;
  321.     InsetRect(&InnerRim,3,3);
  322.     InsetRect(&OuterRim,-(HANDLEWIDTH-2),-(HANDLEWIDTH-2));
  323.     
  324.     PenPat(gray);    PenMode(patXor);    PenSize(1,1);
  325.     if (PtInRect(pt,&OuterRim))
  326.         if (!PtInRect(pt,&InnerRim))
  327.         {
  328.             if (handleNumber = PtInDrawObjectHandle(pt,ObjectH))
  329.             {
  330.                 while (StillDown())
  331.                 {
  332.                         Point    curPos;
  333.                         Rect *rP;
  334.                     
  335.                     rP = &newRect;
  336.                     FrameRect(rP);
  337.                     GetMouse(&curPos);
  338.                     switch (handleNumber)
  339.                     {
  340.                         case 1:        topLeft(*rP) = curPos;        break;
  341.                         case 2:        rP->top = curPos.v;            break;
  342.                         case 3:        rP->top = curPos.v;
  343.                                     rP->right = curPos.h;        break;
  344.                         case 4:        rP->left = curPos.h;        break;
  345.                         case 6:        rP->right = curPos.h;        break;
  346.                         case 7:        rP->bottom = curPos.v;
  347.                                     rP->left = curPos.h;        break;
  348.                         case 8:        rP->bottom = curPos.v;        break;
  349.                         case 9:        botRight(*rP) = curPos;        break;
  350.                 
  351.                     } 
  352.                     FrameRect(rP);
  353.                 }
  354.  
  355.                 EraseRect(&OuterRim);
  356.                 InvalRect(&OuterRim);
  357.                 GetMouse(&endPos);
  358.                 if (PtInRect(endPos,&((*ObjectH)->port)->portRect))
  359.                     Dispatch(ObjectH,RESIZE,&newRect);
  360.             }
  361.         }
  362.     PenNormal();
  363. }
  364. /*------------------------------------------------------------------*/
  365.  
  366. void SelectRect(ObjectH,ParmP)
  367. DrawObjectHandle        ObjectH;
  368. LPtr ParmP;
  369. {
  370.     Rect intersection,*rP;
  371.     
  372.     rP = (Rect *) ParmP;
  373.     SectRect(rP,&(*ObjectH)->bounds,&intersection);
  374.     if (EqualRect(&(*ObjectH)->bounds,&intersection))
  375.     {
  376.         WDispatch((*ObjectH)->port,SELECT,ObjectH);
  377.         Dispatch(ObjectH,SELECT,NULL);
  378.     }
  379. }
  380. /*------------------------------------------------------------------*/
  381. SetLength(ObjectH)
  382. DrawObjectHandle        ObjectH;
  383. {
  384.     (*ObjectH)->length = GetHandleSize(ObjectH) - SKIP2FLDS;
  385. }
  386. /*------------------------------------------------------------------*/
  387.  
  388. Pack(ObjectH,h)
  389. DrawObjectHandle        ObjectH;
  390. Handle h;    
  391. {
  392.     Size size;
  393.     IPtr p;
  394.     
  395.     size = GetHandleSize(h);
  396.     SetHandleSize(h,size + (*ObjectH)->length);        MEM_CHECK
  397.     HLock(h);
  398.  
  399.     p = *h + size;                    /* move to end of existing handle */
  400.     BlockMove(&(*ObjectH)->class,p,(long)(*ObjectH)->length);    
  401.  
  402.     HUnlock(h);
  403. }
  404. /*------------------------------------------------------------------*/
  405. void UnPack(ObjectH,pP)
  406. DrawObjectHandle ObjectH;
  407. Ptr *pP;    
  408. {
  409.     Size obSize;
  410.     IPtr p = *pP;
  411.              
  412.     (*ObjectH)->class = *p++;
  413.     (*ObjectH)->length = *p++;                
  414.     BlockMove(*pP,&(*ObjectH)->class,(long)(*ObjectH)->length);    
  415.     *pP += (*ObjectH)->length;
  416.     
  417. }
  418.